package com.warm.pump.module.skd.dao.gen;

import java.util.List;
import java.util.Map;
import java.util.Date;
import java.math.BigDecimal;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

import com.warm.pump.frame.gen.bean.PageBean;
import com.warm.pump.frame.gen.util.TypeCast;
import com.warm.pump.frame.gen.exception.ServiceException;
import com.warm.pump.module.skd.bean.po.gen.ScheduleJob;
import com.warm.pump.module.skd.mapper.gen.ScheduleJobMapper;
import com.warm.pump.module.skd.bean.po.gen.ScheduleJobExample;

@Repository
public class ScheduleJobDao {
    // 日志对象
    private transient Log log = LogFactory.getLog(this.getClass());
    @Autowired
    private ScheduleJobMapper scheduleJobMapper;

    // 增加一个后台ScheduleJob表

    public boolean insert(ScheduleJob scheduleJob) {
        try {
            scheduleJobMapper.insert(scheduleJob);
            log.debug("后台ScheduleJob表增加成功");
            return true;
        } catch (Exception e) {
            log.debug("后台ScheduleJob表增加失败");
            throw new ServiceException("后台ScheduleJob表增加失败", e);
        }
    }
    // 增加一个后台ScheduleJob表Selective

    public boolean insertSelective(ScheduleJob scheduleJob) {
        try {
            scheduleJobMapper.insertSelective(scheduleJob);
            log.debug("后台ScheduleJob表增加成功");
            return true;
        } catch (Exception e) {
            log.debug("后台ScheduleJob表增加失败");
            throw new ServiceException("后台ScheduleJob表增加失败", e);
        }
    }

    // 删除一个后台ScheduleJob表

    public boolean deleteByPrimaryKey(Long id) {
        try {
            scheduleJobMapper.deleteByPrimaryKey(id);
            log.debug("后台ScheduleJob表删除成功");
            return true;
        } catch (Exception e) {
            log.debug("后台ScheduleJob表删除失败");
            throw new ServiceException("后台ScheduleJob表删除失败", e);
        }
    }
    // 删除一个后台ScheduleJob表byMap

    public boolean deleteByMap(Map scheduleJobMap) {
        try {
            scheduleJobMapper.deleteByExample(createScheduleJobExample(scheduleJobMap, null, null));
            log.debug("后台ScheduleJob根据Map删除成功");
            return true;
        } catch (Exception e) {
            log.debug("后台ScheduleJob根据GroupID删除失败");
            throw new ServiceException("后台ScheduleJob根据object删除失败", e);
        }
    }
    // 修改一个后台ScheduleJob表

    public boolean updateByPrimaryKey(ScheduleJob scheduleJob) {
        try {
            scheduleJobMapper.updateByPrimaryKey(scheduleJob);
            log.debug("后台ScheduleJob表修改成功");
            return true;
        } catch (Exception e) {
            log.debug("后台ScheduleJob表修改失败");
            throw new ServiceException("后台ScheduleJob表修改失败", e);
        }
    }
    // 修改一个后台ScheduleJob表Selective

    public boolean updateByPrimaryKeySelective(ScheduleJob scheduleJob) {
        try {
            scheduleJobMapper.updateByPrimaryKeySelective(scheduleJob);
            log.debug("后台ScheduleJob表修改成功");
            return true;
        } catch (Exception e) {
            log.debug("后台ScheduleJob表修改失败");
            throw new ServiceException("后台ScheduleJob表修改失败", e);
        }
    }
    // 修改一个后台ScheduleJob表

    public boolean updateByMap(ScheduleJob scheduleJob, Map scheduleJobMap) {
        try {
            scheduleJobMapper.updateByExample(scheduleJob, createScheduleJobExample(scheduleJobMap, null, null));
            log.debug("后台批量ScheduleJob表修改成功");
            return true;
        } catch (Exception e) {
            log.debug("后台批量ScheduleJob表修改失败");
            throw new ServiceException("后台ScheduleJob表批量修改失败", e);
        }
    }
    // 修改一个后台ScheduleJob表Selective

    public boolean updateByMapSelective(ScheduleJob scheduleJob, Map scheduleJobMap) {
        try {
            scheduleJobMapper.updateByExampleSelective(scheduleJob, createScheduleJobExample(scheduleJobMap, null, null));
            log.debug("后台批量ScheduleJob表修改成功");
            return true;
        } catch (Exception e) {
            log.debug("后台批量ScheduleJob表修改失败");
            throw new ServiceException("后台ScheduleJob表批量修改失败", e);
        }
    }

    // 查询一个后台ScheduleJob表

    public ScheduleJob selectByPrimaryKey(Long id) {
        return scheduleJobMapper.selectByPrimaryKey(id);
    }

    // 查询一个后台ScheduleJob表-根据map

    public ScheduleJob selectByMap(Map scheduleJobMap) {
        List<ScheduleJob> list = getListByMap(scheduleJobMap);
        if (list == null || list.isEmpty()) {
            return null;
        } else {
            return list.get(0);
        }
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    // 查询所有后台ScheduleJob表

    public List<ScheduleJob> getListByMap(Map scheduleJobMap) {

        return scheduleJobMapper.selectByExample(createScheduleJobExample(scheduleJobMap, null, null));
    }

    //统计后台ScheduleJob表数量

    public int countTotalByMap(Map scheduleJobMap) {

        return scheduleJobMapper.countByExample(createScheduleJobExample(scheduleJobMap, null, null));
    }


    public List<ScheduleJob> getListByMapPage(Map scheduleJobMap, int limitStart,
                                              int limitOffset) {

        return scheduleJobMapper.selectByExample(createScheduleJobExample(scheduleJobMap, limitStart, limitOffset));
    }


    public PageBean getPageBeanByMap(Map scheduleJobMap, int pageNo, int pageSize) {
        Integer count = countTotalByMap(scheduleJobMap);
        PageBean pageBean = new PageBean();
        pageBean.setCount(count);
        pageBean.setPageNo(pageNo);
        pageBean.setPageSize(pageSize);
        int limitStart = pageBean.getStartNo();
        int limitOffset = pageSize;
        pageBean.setData(scheduleJobMapper.selectByExample(createScheduleJobExample(scheduleJobMap, limitStart, limitOffset)));
        return pageBean;
    }

    private ScheduleJobExample createScheduleJobExample(Map scheduleJobMap, Integer limitStart, Integer limitOffset) {
        ScheduleJobExample scheduleJobEx = new ScheduleJobExample();
        ScheduleJobExample.Criteria c = scheduleJobEx.createCriteria();
        Long id_null = TypeCast.getLong(scheduleJobMap.get("id_null"));
        Long id_notNull = TypeCast.getLong(scheduleJobMap.get("id_notNull"));
        Long id = TypeCast.getLong(scheduleJobMap.get("id"));
        Long id_not = TypeCast.getLong(scheduleJobMap.get("id_not"));
        Long id_greater = TypeCast.getLong(scheduleJobMap.get("id_greater"));
        Long id_greaterEqual = TypeCast.getLong(scheduleJobMap.get("id_greaterEqual"));
        Long id_less = TypeCast.getLong(scheduleJobMap.get("id_less"));
        Long id_lessEqual = TypeCast.getLong(scheduleJobMap.get("id_lessEqual"));
        List<Long> id_in = TypeCast.getLongList(scheduleJobMap.get("id_in"));
        List<Long> id_notIn = TypeCast.getLongList(scheduleJobMap.get("id_notIn"));
        Long id_between1 = TypeCast.getLong(scheduleJobMap.get("id_between1"));
        Long id_between2 = TypeCast.getLong(scheduleJobMap.get("id_between2"));
        Long id_notBetween1 = TypeCast.getLong(scheduleJobMap.get("id_notBetween1"));
        Long id_notBetween2 = TypeCast.getLong(scheduleJobMap.get("id_notBetween2"));

        if (id_null != null) {
            c.andIdIsNull();
        }
        if (id_notNull != null) {
            c.andIdIsNotNull();
        }
        if (id != null) {
            c.andIdEqualTo(id);
        }
        if (id_not != null) {
            c.andIdNotEqualTo(id_not);
        }
        if (id_greater != null) {
            c.andIdGreaterThan(id_greater);
        }
        if (id_greaterEqual != null) {
            c.andIdGreaterThanOrEqualTo(id_greaterEqual);
        }
        if (id_less != null) {
            c.andIdLessThan(id_less);
        }
        if (id_lessEqual != null) {
            c.andIdLessThanOrEqualTo(id_lessEqual);
        }
        if (id_in != null) {
            c.andIdIn(id_in);
        }
        if (id_notIn != null) {
            c.andIdNotIn(id_notIn);
        }
        if (id_between1 != null) {
            c.andIdBetween(id_between1, id_between2);
        }
        if (id_notBetween1 != null) {
            c.andIdNotBetween(id_notBetween1, id_notBetween2);
        }
        String jobName_null = TypeCast.getString(scheduleJobMap.get("jobName_null"));
        String jobName_notNull = TypeCast.getString(scheduleJobMap.get("jobName_notNull"));
        String jobName = TypeCast.getString(scheduleJobMap.get("jobName"));
        String jobName_not = TypeCast.getString(scheduleJobMap.get("jobName_not"));
        String jobName_greater = TypeCast.getString(scheduleJobMap.get("jobName_greater"));
        String jobName_greaterEqual = TypeCast.getString(scheduleJobMap.get("jobName_greaterEqual"));
        String jobName_less = TypeCast.getString(scheduleJobMap.get("jobName_less"));
        String jobName_lessEqual = TypeCast.getString(scheduleJobMap.get("jobName_lessEqual"));
        String jobName_like = TypeCast.getString(scheduleJobMap.get("jobName_like"));
        String jobName_notLike = TypeCast.getString(scheduleJobMap.get("jobName_notLike"));
        List<String> jobName_in = TypeCast.getStringList(scheduleJobMap.get("jobName_in"));
        List<String> jobName_notIn = TypeCast.getStringList(scheduleJobMap.get("jobName_notIn"));
        String jobName_between1 = TypeCast.getString(scheduleJobMap.get("jobName_between1"));
        String jobName_between2 = TypeCast.getString(scheduleJobMap.get("jobName_between2"));
        String jobName_notBetween1 = TypeCast.getString(scheduleJobMap.get("jobName_notBetween1"));
        String jobName_notBetween2 = TypeCast.getString(scheduleJobMap.get("jobName_notBetween2"));

        if (jobName_null != null) {
            c.andJobNameIsNull();
        }
        if (jobName_notNull != null) {
            c.andJobNameIsNotNull();
        }
        if (jobName != null) {
            c.andJobNameEqualTo(jobName);
        }
        if (jobName_not != null) {
            c.andJobNameNotEqualTo(jobName_not);
        }
        if (jobName_greater != null) {
            c.andJobNameGreaterThan(jobName_greater);
        }
        if (jobName_greaterEqual != null) {
            c.andJobNameGreaterThanOrEqualTo(jobName_greaterEqual);
        }
        if (jobName_less != null) {
            c.andJobNameLessThan(jobName_less);
        }
        if (jobName_lessEqual != null) {
            c.andJobNameLessThanOrEqualTo(jobName_lessEqual);
        }
        if (jobName_like != null) {
            c.andJobNameLike(jobName_like);
        }
        if (jobName_notLike != null) {
            c.andJobNameNotLike(jobName_notLike);
        }
        if (jobName_in != null) {
            c.andJobNameIn(jobName_in);
        }
        if (jobName_notIn != null) {
            c.andJobNameNotIn(jobName_notIn);
        }
        if (jobName_between1 != null) {
            c.andJobNameBetween(jobName_between1, jobName_between2);
        }
        if (jobName_notBetween1 != null) {
            c.andJobNameNotBetween(jobName_notBetween1, jobName_notBetween2);
        }
        Integer status_null = TypeCast.getInteger(scheduleJobMap.get("status_null"));
        Integer status_notNull = TypeCast.getInteger(scheduleJobMap.get("status_notNull"));
        Integer status = TypeCast.getInteger(scheduleJobMap.get("status"));
        Integer status_not = TypeCast.getInteger(scheduleJobMap.get("status_not"));
        Integer status_greater = TypeCast.getInteger(scheduleJobMap.get("status_greater"));
        Integer status_greaterEqual = TypeCast.getInteger(scheduleJobMap.get("status_greaterEqual"));
        Integer status_less = TypeCast.getInteger(scheduleJobMap.get("status_less"));
        Integer status_lessEqual = TypeCast.getInteger(scheduleJobMap.get("status_lessEqual"));
        List<Integer> status_in = TypeCast.getIntegerList(scheduleJobMap.get("status_in"));
        List<Integer> status_notIn = TypeCast.getIntegerList(scheduleJobMap.get("status_notIn"));
        Integer status_between1 = TypeCast.getInteger(scheduleJobMap.get("status_between1"));
        Integer status_between2 = TypeCast.getInteger(scheduleJobMap.get("status_between2"));
        Integer status_notBetween1 = TypeCast.getInteger(scheduleJobMap.get("status_notBetween1"));
        Integer status_notBetween2 = TypeCast.getInteger(scheduleJobMap.get("status_notBetween2"));

        if (status_null != null) {
            c.andStatusIsNull();
        }
        if (status_notNull != null) {
            c.andStatusIsNotNull();
        }
        if (status != null) {
            c.andStatusEqualTo(status);
        }
        if (status_not != null) {
            c.andStatusNotEqualTo(status_not);
        }
        if (status_greater != null) {
            c.andStatusGreaterThan(status_greater);
        }
        if (status_greaterEqual != null) {
            c.andStatusGreaterThanOrEqualTo(status_greaterEqual);
        }
        if (status_less != null) {
            c.andStatusLessThan(status_less);
        }
        if (status_lessEqual != null) {
            c.andStatusLessThanOrEqualTo(status_lessEqual);
        }
        if (status_in != null) {
            c.andStatusIn(status_in);
        }
        if (status_notIn != null) {
            c.andStatusNotIn(status_notIn);
        }
        if (status_between1 != null) {
            c.andStatusBetween(status_between1, status_between2);
        }
        if (status_notBetween1 != null) {
            c.andStatusNotBetween(status_notBetween1, status_notBetween2);
        }
        String cronExpression_null = TypeCast.getString(scheduleJobMap.get("cronExpression_null"));
        String cronExpression_notNull = TypeCast.getString(scheduleJobMap.get("cronExpression_notNull"));
        String cronExpression = TypeCast.getString(scheduleJobMap.get("cronExpression"));
        String cronExpression_not = TypeCast.getString(scheduleJobMap.get("cronExpression_not"));
        String cronExpression_greater = TypeCast.getString(scheduleJobMap.get("cronExpression_greater"));
        String cronExpression_greaterEqual = TypeCast.getString(scheduleJobMap.get("cronExpression_greaterEqual"));
        String cronExpression_less = TypeCast.getString(scheduleJobMap.get("cronExpression_less"));
        String cronExpression_lessEqual = TypeCast.getString(scheduleJobMap.get("cronExpression_lessEqual"));
        String cronExpression_like = TypeCast.getString(scheduleJobMap.get("cronExpression_like"));
        String cronExpression_notLike = TypeCast.getString(scheduleJobMap.get("cronExpression_notLike"));
        List<String> cronExpression_in = TypeCast.getStringList(scheduleJobMap.get("cronExpression_in"));
        List<String> cronExpression_notIn = TypeCast.getStringList(scheduleJobMap.get("cronExpression_notIn"));
        String cronExpression_between1 = TypeCast.getString(scheduleJobMap.get("cronExpression_between1"));
        String cronExpression_between2 = TypeCast.getString(scheduleJobMap.get("cronExpression_between2"));
        String cronExpression_notBetween1 = TypeCast.getString(scheduleJobMap.get("cronExpression_notBetween1"));
        String cronExpression_notBetween2 = TypeCast.getString(scheduleJobMap.get("cronExpression_notBetween2"));

        if (cronExpression_null != null) {
            c.andCronExpressionIsNull();
        }
        if (cronExpression_notNull != null) {
            c.andCronExpressionIsNotNull();
        }
        if (cronExpression != null) {
            c.andCronExpressionEqualTo(cronExpression);
        }
        if (cronExpression_not != null) {
            c.andCronExpressionNotEqualTo(cronExpression_not);
        }
        if (cronExpression_greater != null) {
            c.andCronExpressionGreaterThan(cronExpression_greater);
        }
        if (cronExpression_greaterEqual != null) {
            c.andCronExpressionGreaterThanOrEqualTo(cronExpression_greaterEqual);
        }
        if (cronExpression_less != null) {
            c.andCronExpressionLessThan(cronExpression_less);
        }
        if (cronExpression_lessEqual != null) {
            c.andCronExpressionLessThanOrEqualTo(cronExpression_lessEqual);
        }
        if (cronExpression_like != null) {
            c.andCronExpressionLike(cronExpression_like);
        }
        if (cronExpression_notLike != null) {
            c.andCronExpressionNotLike(cronExpression_notLike);
        }
        if (cronExpression_in != null) {
            c.andCronExpressionIn(cronExpression_in);
        }
        if (cronExpression_notIn != null) {
            c.andCronExpressionNotIn(cronExpression_notIn);
        }
        if (cronExpression_between1 != null) {
            c.andCronExpressionBetween(cronExpression_between1, cronExpression_between2);
        }
        if (cronExpression_notBetween1 != null) {
            c.andCronExpressionNotBetween(cronExpression_notBetween1, cronExpression_notBetween2);
        }
        String remark_null = TypeCast.getString(scheduleJobMap.get("remark_null"));
        String remark_notNull = TypeCast.getString(scheduleJobMap.get("remark_notNull"));
        String remark = TypeCast.getString(scheduleJobMap.get("remark"));
        String remark_not = TypeCast.getString(scheduleJobMap.get("remark_not"));
        String remark_greater = TypeCast.getString(scheduleJobMap.get("remark_greater"));
        String remark_greaterEqual = TypeCast.getString(scheduleJobMap.get("remark_greaterEqual"));
        String remark_less = TypeCast.getString(scheduleJobMap.get("remark_less"));
        String remark_lessEqual = TypeCast.getString(scheduleJobMap.get("remark_lessEqual"));
        String remark_like = TypeCast.getString(scheduleJobMap.get("remark_like"));
        String remark_notLike = TypeCast.getString(scheduleJobMap.get("remark_notLike"));
        List<String> remark_in = TypeCast.getStringList(scheduleJobMap.get("remark_in"));
        List<String> remark_notIn = TypeCast.getStringList(scheduleJobMap.get("remark_notIn"));
        String remark_between1 = TypeCast.getString(scheduleJobMap.get("remark_between1"));
        String remark_between2 = TypeCast.getString(scheduleJobMap.get("remark_between2"));
        String remark_notBetween1 = TypeCast.getString(scheduleJobMap.get("remark_notBetween1"));
        String remark_notBetween2 = TypeCast.getString(scheduleJobMap.get("remark_notBetween2"));

        if (remark_null != null) {
            c.andRemarkIsNull();
        }
        if (remark_notNull != null) {
            c.andRemarkIsNotNull();
        }
        if (remark != null) {
            c.andRemarkEqualTo(remark);
        }
        if (remark_not != null) {
            c.andRemarkNotEqualTo(remark_not);
        }
        if (remark_greater != null) {
            c.andRemarkGreaterThan(remark_greater);
        }
        if (remark_greaterEqual != null) {
            c.andRemarkGreaterThanOrEqualTo(remark_greaterEqual);
        }
        if (remark_less != null) {
            c.andRemarkLessThan(remark_less);
        }
        if (remark_lessEqual != null) {
            c.andRemarkLessThanOrEqualTo(remark_lessEqual);
        }
        if (remark_like != null) {
            c.andRemarkLike(remark_like);
        }
        if (remark_notLike != null) {
            c.andRemarkNotLike(remark_notLike);
        }
        if (remark_in != null) {
            c.andRemarkIn(remark_in);
        }
        if (remark_notIn != null) {
            c.andRemarkNotIn(remark_notIn);
        }
        if (remark_between1 != null) {
            c.andRemarkBetween(remark_between1, remark_between2);
        }
        if (remark_notBetween1 != null) {
            c.andRemarkNotBetween(remark_notBetween1, remark_notBetween2);
        }
        Date createTime_null = TypeCast.getDate(scheduleJobMap.get("createTime_null"));
        Date createTime_notNull = TypeCast.getDate(scheduleJobMap.get("createTime_notNull"));
        Date createTime = TypeCast.getDate(scheduleJobMap.get("createTime"));
        Date createTime_not = TypeCast.getDate(scheduleJobMap.get("createTime_not"));
        Date createTime_greater = TypeCast.getDate(scheduleJobMap.get("createTime_greater"));
        Date createTime_greaterEqual = TypeCast.getDate(scheduleJobMap.get("createTime_greaterEqual"));
        Date createTime_less = TypeCast.getDate(scheduleJobMap.get("createTime_less"));
        Date createTime_lessEqual = TypeCast.getDate(scheduleJobMap.get("createTime_lessEqual"));
        List<Date> createTime_in = TypeCast.getDateList(scheduleJobMap.get("createTime_in"));
        List<Date> createTime_notIn = TypeCast.getDateList(scheduleJobMap.get("createTime_notIn"));
        Date createTime_between1 = TypeCast.getDate(scheduleJobMap.get("createTime_between1"));
        Date createTime_between2 = TypeCast.getDate(scheduleJobMap.get("createTime_between2"));
        Date createTime_notBetween1 = TypeCast.getDate(scheduleJobMap.get("createTime_notBetween1"));
        Date createTime_notBetween2 = TypeCast.getDate(scheduleJobMap.get("createTime_notBetween2"));

        if (createTime_null != null) {
            c.andCreateTimeIsNull();
        }
        if (createTime_notNull != null) {
            c.andCreateTimeIsNotNull();
        }
        if (createTime != null) {
            c.andCreateTimeEqualTo(createTime);
        }
        if (createTime_not != null) {
            c.andCreateTimeNotEqualTo(createTime_not);
        }
        if (createTime_greater != null) {
            c.andCreateTimeGreaterThan(createTime_greater);
        }
        if (createTime_greaterEqual != null) {
            c.andCreateTimeGreaterThanOrEqualTo(createTime_greaterEqual);
        }
        if (createTime_less != null) {
            c.andCreateTimeLessThan(createTime_less);
        }
        if (createTime_lessEqual != null) {
            c.andCreateTimeLessThanOrEqualTo(createTime_lessEqual);
        }
        if (createTime_in != null) {
            c.andCreateTimeIn(createTime_in);
        }
        if (createTime_notIn != null) {
            c.andCreateTimeNotIn(createTime_notIn);
        }
        if (createTime_between1 != null) {
            c.andCreateTimeBetween(createTime_between1, createTime_between2);
        }
        if (createTime_notBetween1 != null) {
            c.andCreateTimeNotBetween(createTime_notBetween1, createTime_notBetween2);
        }
        Date updateTime_null = TypeCast.getDate(scheduleJobMap.get("updateTime_null"));
        Date updateTime_notNull = TypeCast.getDate(scheduleJobMap.get("updateTime_notNull"));
        Date updateTime = TypeCast.getDate(scheduleJobMap.get("updateTime"));
        Date updateTime_not = TypeCast.getDate(scheduleJobMap.get("updateTime_not"));
        Date updateTime_greater = TypeCast.getDate(scheduleJobMap.get("updateTime_greater"));
        Date updateTime_greaterEqual = TypeCast.getDate(scheduleJobMap.get("updateTime_greaterEqual"));
        Date updateTime_less = TypeCast.getDate(scheduleJobMap.get("updateTime_less"));
        Date updateTime_lessEqual = TypeCast.getDate(scheduleJobMap.get("updateTime_lessEqual"));
        List<Date> updateTime_in = TypeCast.getDateList(scheduleJobMap.get("updateTime_in"));
        List<Date> updateTime_notIn = TypeCast.getDateList(scheduleJobMap.get("updateTime_notIn"));
        Date updateTime_between1 = TypeCast.getDate(scheduleJobMap.get("updateTime_between1"));
        Date updateTime_between2 = TypeCast.getDate(scheduleJobMap.get("updateTime_between2"));
        Date updateTime_notBetween1 = TypeCast.getDate(scheduleJobMap.get("updateTime_notBetween1"));
        Date updateTime_notBetween2 = TypeCast.getDate(scheduleJobMap.get("updateTime_notBetween2"));

        if (updateTime_null != null) {
            c.andUpdateTimeIsNull();
        }
        if (updateTime_notNull != null) {
            c.andUpdateTimeIsNotNull();
        }
        if (updateTime != null) {
            c.andUpdateTimeEqualTo(updateTime);
        }
        if (updateTime_not != null) {
            c.andUpdateTimeNotEqualTo(updateTime_not);
        }
        if (updateTime_greater != null) {
            c.andUpdateTimeGreaterThan(updateTime_greater);
        }
        if (updateTime_greaterEqual != null) {
            c.andUpdateTimeGreaterThanOrEqualTo(updateTime_greaterEqual);
        }
        if (updateTime_less != null) {
            c.andUpdateTimeLessThan(updateTime_less);
        }
        if (updateTime_lessEqual != null) {
            c.andUpdateTimeLessThanOrEqualTo(updateTime_lessEqual);
        }
        if (updateTime_in != null) {
            c.andUpdateTimeIn(updateTime_in);
        }
        if (updateTime_notIn != null) {
            c.andUpdateTimeNotIn(updateTime_notIn);
        }
        if (updateTime_between1 != null) {
            c.andUpdateTimeBetween(updateTime_between1, updateTime_between2);
        }
        if (updateTime_notBetween1 != null) {
            c.andUpdateTimeNotBetween(updateTime_notBetween1, updateTime_notBetween2);
        }
        String misfireInformIds_null = TypeCast.getString(scheduleJobMap.get("misfireInformIds_null"));
        String misfireInformIds_notNull = TypeCast.getString(scheduleJobMap.get("misfireInformIds_notNull"));
        String misfireInformIds = TypeCast.getString(scheduleJobMap.get("misfireInformIds"));
        String misfireInformIds_not = TypeCast.getString(scheduleJobMap.get("misfireInformIds_not"));
        String misfireInformIds_greater = TypeCast.getString(scheduleJobMap.get("misfireInformIds_greater"));
        String misfireInformIds_greaterEqual = TypeCast.getString(scheduleJobMap.get("misfireInformIds_greaterEqual"));
        String misfireInformIds_less = TypeCast.getString(scheduleJobMap.get("misfireInformIds_less"));
        String misfireInformIds_lessEqual = TypeCast.getString(scheduleJobMap.get("misfireInformIds_lessEqual"));
        String misfireInformIds_like = TypeCast.getString(scheduleJobMap.get("misfireInformIds_like"));
        String misfireInformIds_notLike = TypeCast.getString(scheduleJobMap.get("misfireInformIds_notLike"));
        List<String> misfireInformIds_in = TypeCast.getStringList(scheduleJobMap.get("misfireInformIds_in"));
        List<String> misfireInformIds_notIn = TypeCast.getStringList(scheduleJobMap.get("misfireInformIds_notIn"));
        String misfireInformIds_between1 = TypeCast.getString(scheduleJobMap.get("misfireInformIds_between1"));
        String misfireInformIds_between2 = TypeCast.getString(scheduleJobMap.get("misfireInformIds_between2"));
        String misfireInformIds_notBetween1 = TypeCast.getString(scheduleJobMap.get("misfireInformIds_notBetween1"));
        String misfireInformIds_notBetween2 = TypeCast.getString(scheduleJobMap.get("misfireInformIds_notBetween2"));

        if (misfireInformIds_null != null) {
            c.andMisfireInformIdsIsNull();
        }
        if (misfireInformIds_notNull != null) {
            c.andMisfireInformIdsIsNotNull();
        }
        if (misfireInformIds != null) {
            c.andMisfireInformIdsEqualTo(misfireInformIds);
        }
        if (misfireInformIds_not != null) {
            c.andMisfireInformIdsNotEqualTo(misfireInformIds_not);
        }
        if (misfireInformIds_greater != null) {
            c.andMisfireInformIdsGreaterThan(misfireInformIds_greater);
        }
        if (misfireInformIds_greaterEqual != null) {
            c.andMisfireInformIdsGreaterThanOrEqualTo(misfireInformIds_greaterEqual);
        }
        if (misfireInformIds_less != null) {
            c.andMisfireInformIdsLessThan(misfireInformIds_less);
        }
        if (misfireInformIds_lessEqual != null) {
            c.andMisfireInformIdsLessThanOrEqualTo(misfireInformIds_lessEqual);
        }
        if (misfireInformIds_like != null) {
            c.andMisfireInformIdsLike(misfireInformIds_like);
        }
        if (misfireInformIds_notLike != null) {
            c.andMisfireInformIdsNotLike(misfireInformIds_notLike);
        }
        if (misfireInformIds_in != null) {
            c.andMisfireInformIdsIn(misfireInformIds_in);
        }
        if (misfireInformIds_notIn != null) {
            c.andMisfireInformIdsNotIn(misfireInformIds_notIn);
        }
        if (misfireInformIds_between1 != null) {
            c.andMisfireInformIdsBetween(misfireInformIds_between1, misfireInformIds_between2);
        }
        if (misfireInformIds_notBetween1 != null) {
            c.andMisfireInformIdsNotBetween(misfireInformIds_notBetween1, misfireInformIds_notBetween2);
        }
        if (scheduleJobMap.get("orderBy") != null) {
            scheduleJobEx.setOrderByClause((String) scheduleJobMap.get("orderBy"));
        }
        if (limitStart != null && limitOffset != null) {
            scheduleJobEx.setLimitStart(limitStart);
            scheduleJobEx.setLimitOffset(limitOffset);
        }

        return scheduleJobEx;
    }
}
